const jieba = require("@node-rs/jieba");
const fs = require('fs');
const path = require('path');

/**
 * Jieba 分词配置模块
 * 统一管理词典加载、关键词提取等功能
 * 使用 @node-rs/jieba 1.x (稳定版本，功能完整)
 */

// 词典和停用词是否已加载
let isDictLoaded = false;
let stopWords = new Set();

/**
 * 初始化 jieba：加载自定义词典和停用词表
 */
function initJieba() {
    if (isDictLoaded) {
        return; // 已加载，避免重复
    }

    try {
        // 加载自定义词典
        const userDictPath = path.join(__dirname, 'dict/userdict.txt');
        if (fs.existsSync(userDictPath)) {
            const userDict = fs.readFileSync(userDictPath, 'utf-8');
            const dictBuffer = Buffer.from(userDict, 'utf-8');
            jieba.loadDict(dictBuffer);
            console.log('✅ 自定义词典加载成功');
        } else {
            console.warn('⚠️ 自定义词典文件不存在:', userDictPath);
        }

        // 加载停用词表
        const stopWordsPath = path.join(__dirname, 'dict/stopwords.txt');
        if (fs.existsSync(stopWordsPath)) {
            const stopWordsContent = fs.readFileSync(stopWordsPath, 'utf-8');
            stopWords = new Set(
                stopWordsContent
                    .split('\n')
                    .map(w => w.trim())
                    .filter(w => w.length > 0)
            );
            console.log(`✅ 停用词表加载成功 (共${stopWords.size}个停用词)`);
        } else {
            console.warn('⚠️ 停用词表文件不存在:', stopWordsPath);
        }

        isDictLoaded = true;
    } catch (error) {
        console.error('❌ Jieba 初始化失败:', error);
    }
}

/**
 * 提取关键词（基于 TF-IDF 算法）
 * @param {string} text - 待提取的文本
 * @param {number} topN - 提取关键词数量，默认8个
 * @returns {string[]} 关键词数组
 */
function extractKeywords(text, topN = 8) {
    // 确保已初始化
    initJieba();

    if (!text || typeof text !== 'string' || text.trim().length === 0) {
        console.log('⚠️ 文本为空，无法提取关键词');
        return [];
    }

    try {
        // 使用 jieba.extract() 进行关键词提取（基于 TF-IDF）
        const keywords = jieba.extract(text, topN);

        // 过滤停用词和无意义词
        const filteredKeywords = keywords.filter(kw => {
            const word = kw.keyword;
            // 过滤停用词
            if (stopWords.has(word)) return false;
            // 过滤纯数字
            if (/^\d+$/.test(word)) return false;
            // 过滤单字符（除非权重特别高）
            if (word.length === 1 && kw.weight < 5) return false;
            return true;
        });

        const result = filteredKeywords.map(kw => kw.keyword);
        console.log('🎯 提取关键词:', result.join(', '));

        return result;
    } catch (error) {
        console.error('❌ 关键词提取失败:', error);
        return [];
    }
}

/**
 * 分词（用于专题匹配等场景）
 * @param {string} text - 待分词的文本
 * @param {boolean} hmm - 是否使用HMM模型，默认true
 * @returns {string[]} 分词结果数组
 */
function cut(text, hmm = true) {
    // 确保已初始化
    initJieba();

    if (!text || typeof text !== 'string') {
        return [];
    }

    try {
        return jieba.cut(text, hmm);
    } catch (error) {
        console.error('❌ 分词失败:', error);
        return [];
    }
}

/**
 * 词性标注
 * @param {string} text - 待标注的文本
 * @returns {Array<{word: string, tag: string}>} 词性标注结果
 */
function tag(text) {
    // 确保已初始化
    initJieba();

    if (!text || typeof text !== 'string') {
        return [];
    }

    try {
        return jieba.tag(text);
    } catch (error) {
        console.error('❌ 词性标注失败:', error);
        return [];
    }
}

/**
 * 智能匹配专题
 * @param {string} title - 文件标题
 * @param {string} pptText - PPT文本内容
 * @param {Array} artTypeList - 专题列表
 * @returns {string|null} 匹配的专题ID，未匹配返回null
 */
function matchArtType(title, pptText, artTypeList) {
    // 确保已初始化
    initJieba();

    if (!title || !artTypeList || artTypeList.length === 0) {
        return null;
    }

    // 使用 jieba 对标题进行分词
    const titleWords = cut(title, true);
    const titleWordSet = new Set(titleWords.filter(w => w.length >= 2));

    console.log(`📝 标题分词结果: ${Array.from(titleWordSet).join(', ')}`);

    // 遍历所有专题，计算匹配度
    let bestMatch = null;
    let maxScore = 0;

    for (const artType of artTypeList) {
        const typeName = artType.name || '';
        const typeDesc = artType.desc || '';
        let score = 0;

        // 策略1: 标题完全包含专题名称（权重最高）
        if (title.includes(typeName)) {
            score += 100;
            console.log(`  ✓ "${typeName}" 标题完全匹配 (+100)`);
        }

        // 策略2: 专题名称的分词匹配
        const typeNameWords = cut(typeName, true);
        for (const word of typeNameWords) {
            if (word.length >= 2 && titleWordSet.has(word)) {
                score += 30;
                console.log(`  ✓ "${typeName}" 分词匹配: "${word}" (+30)`);
            }
        }

        // 策略3: PPT内容包含专题名称
        if (pptText && pptText.includes(typeName)) {
            score += 20;
            console.log(`  ✓ "${typeName}" PPT内容匹配 (+20)`);
        }

        // 策略4: 专题描述的关键词匹配
        if (typeDesc) {
            const descWords = cut(typeDesc, true);
            for (const word of descWords) {
                if (word.length >= 2 && titleWordSet.has(word)) {
                    score += 10;
                    console.log(`  ✓ "${typeName}" 描述匹配: "${word}" (+10)`);
                }
            }
        }

        // 策略5: 专题自定义关键词匹配（权重较高）
        const typeKeyWords = artType.keyWords || '';
        if (typeKeyWords) {
            // 将关键词按逗号分隔，并去除空格
            const keywords = typeKeyWords.split(',').map(kw => kw.trim()).filter(kw => kw);
            for (const keyword of keywords) {
                // 完全匹配标题
                if (title.includes(keyword)) {
                    score += 50;
                    console.log(`  ✓ "${typeName}" 关键词完全匹配: "${keyword}" (+50)`);
                }
                // 匹配标题分词
                else if (titleWordSet.has(keyword)) {
                    score += 40;
                    console.log(`  ✓ "${typeName}" 关键词分词匹配: "${keyword}" (+40)`);
                }
            }
        }

        // 记录最高分
        if (score > maxScore) {
            maxScore = score;
            bestMatch = artType;
        }
    }

    // 只有分数 >= 30 才认为匹配成功（避免误判）
    if (maxScore >= 30 && bestMatch) {
        console.log(`🎯 最佳匹配: "${bestMatch.name}" (得分: ${maxScore})`);
        return bestMatch.objectId;
    }

    console.log(`❌ 未找到合适的专题 (最高分: ${maxScore})`);
    return null;
}

/**
 * 获取停用词集合（用于外部自定义过滤）
 * @returns {Set<string>} 停用词集合
 */
function getStopWords() {
    initJieba();
    return stopWords;
}

// 导出模块
module.exports = {
    initJieba,
    extractKeywords,
    cut,
    tag,
    matchArtType,
    getStopWords
};
